Memory device perforamnce based on storage traffic pattern detection

ABSTRACT

A processing device of a memory sub-system can monitor a plurality of received commands to identify a forced unit access command. The processing device can identify a metadata area of the memory device based on the forced unit access command. The processing device can also perform an action responsive to identifying a subsequent forced unit access command to the metadata area.

TECHNICAL FIELD

Embodiments of the disclosure relate generally to memory sub-systems, and more specifically, relate to improved memory device performance based on storage traffic pattern detection.

BACKGROUND

A memory sub-system can include one or more memory devices that store data. The memory devices can be, for example, non-volatile memory devices and volatile memory devices. In general, a host system can utilize a memory sub-system to store data at the memory devices and to retrieve data from the memory devices.

BRIEF DESCRIPTION OF THE DRAWINGS

The present disclosure will be understood more fully from the detailed description given below and from the accompanying drawings of various embodiments of the disclosure.

FIG. 1 illustrates an example computing system that includes a memory sub-system in accordance with some embodiments of the present disclosure.

FIG. 2 is a graph illustrating LBAs to which a sequence of commands are directed in accordance with some embodiments of the present disclosure.

FIG. 3 illustrates an example virtual block in accordance with some embodiments of the present disclosure.

FIG. 4 is a flow diagram of an example method for improved memory device performance based on storage traffic pattern detection in accordance with some embodiments of the present disclosure.

FIG. 5 is a block diagram of an example computer system in which embodiments of the present disclosure may operate.

DETAILED DESCRIPTION

Various embodiments of the present disclosure are directed to memory sub-systems for improved memory device performance based on storage traffic pattern detection. A memory sub-system can be a storage device, a memory module, or a hybrid of a storage device and memory module. Examples of storage devices and memory modules are described below in conjunction with FIG. 1. In general, a host system can utilize a memory sub-system that includes one or more memory devices, such as memory devices that store data. The host system can provide data to be stored at the memory sub-system and can request data to be retrieved from the memory sub-system.

The host system can send access requests (e.g., write command, read command) to the memory sub-system, such as to store data on a memory device of the memory sub-system and to read data from the memory device. The data to be read or written, as specified by a host request, is hereinafter referred to as “host data” or “user data”. A host request can include logical address information (e.g., logical block address (LBA), namespace) for the host data, which is the location the host system associates with the host data. The host system can implement a file system to store the host data/user data in the memory sub-system. As used herein, a file system can comprise software that is implemented to control how data is stored and/or retrieved from the memory sub-system.

Write sequences for a particular file system can include write commands for a portion of memory that stores metadata. Write commands to logical block addresses (LBAs) may be stored in cache. Periodically, the data stored to the cache can be committed to a memory device of the memory sub-system. Some systems (e.g., fourth extended (EXT4) file system) block operations to the storage device until data and related metadata movement from cache to a memory device is successfully completed. The inability to process commands at a memory sub-system can lead to perceived system lag by a user. For example, some accesses to a file system may be temporarily unavailable (e.g., blocked) until particular operations, which may be considered system critical, are successfully completed. Such operations can include writes to particular metadata areas, which may be in association with a journal commit operation or other operation designed to maintain data integrity, for example. Accordingly, the unavailability of the file system for processing user level commands while it services particular metadata writes can be perceived as system lag, which may degrade user experience.

Various embodiments of the present disclosure address the above and other deficiencies. For example, a number of embodiments can provide for improved latency of operations directed to metadata areas associated with a file system, thereby improving user experience. For example, a number of embodiments can include identifying a particular file system based on input/output (TO) patterns. A particular area (e.g., LBA range) of the memory device used to store metadata for the file system can also be identified, and actions can be taken in order to improve the latency of accesses to the identified metadata areas. For example, a block of a memory device can be reserved for a metadata area, a garbage collection policy may be implemented for the metadata area, and/or accesses to the metadata area may be prioritized over various other operations such as background and/or housekeeping operations including garbage collection operations.

As used herein, metadata refers to data that describes different data. Metadata can include data that describes file structures and/or data that describes a file system. For instance, metadata can be used for data integrity. Metadata can include specialized data structures which can describe internal file system structures (e.g., EXT4 journal). A metadata area describes a portion (e.g., LBA range) of a memory device used to store the metadata.

The figures herein follow a numbering convention in which the first digit or digits correspond to the drawing figure number and the remaining digits identify an element or component in the drawing. Similar elements or components between different figures may be identified by the use of similar digits. For example, 105 may reference element “05” in FIG. 1, and a similar element may be referenced as 305 in FIG. 3. Analogous elements within a figure may be referenced with a hyphen and extra numeral or letter. See, for example, elements 226-1, . . . , 226-5 in FIG. 2. As will be appreciated, elements shown in the various embodiments herein can be added, exchanged, and/or eliminated so as to provide a number of additional embodiments of the present disclosure. In addition, as will be appreciated, the proportion and the relative scale of the elements provided in the figures are intended to illustrate certain embodiments of the present invention and should not be taken in a limiting sense.

FIG. 1 illustrates an example computing system 100 that includes a memory sub-system 103 in accordance with some embodiments of the present disclosure. The memory sub-system 103 can include media, such as one or more volatile memory devices (e.g., memory device 106), one or more non-volatile memory devices (e.g., memory device 105), or a combination of such.

A memory sub-system 103 can be a storage device, a memory module, or a hybrid of a storage device and memory module. Examples of a storage device include a solid-state drive (SSD), a flash drive, a universal serial bus (USB) flash drive, an embedded Multi-Media Controller (eMMC) drive, a Universal Flash Storage (UFS) drive, a secure digital (SD) card, and a hard disk drive (HDD). Examples of memory modules include a dual in-line memory module (DIMM), a small outline DIMM (SO-DIMM), and various types of non-volatile dual in-line memory module (NVDIMM).

The computing system 100 can be a computing device such as a desktop computer, laptop computer, network server, mobile device, a vehicle (e.g., airplane, drone, train, automobile, or other conveyance), Internet of Things (IoT) enabled device, embedded computer (e.g., one included in a vehicle, industrial equipment, or a networked commercial device), or such computing device that includes memory and a processing device.

The computing system 100 can include a host system 102 that is coupled to one or more memory sub-systems 103. In some embodiments, the host system 102 is coupled to different types of memory sub-systems 103. FIG. 1 illustrates an example of a host system 102 coupled to one memory sub-system 103. As used herein, “coupled to” or “coupled with” generally refers to a connection between components, which can be an indirect communicative connection or direct communicative connection (e.g., without intervening components), whether wired or wireless, including connections such as electrical, optical, magnetic, and the like.

The host system 102 can include a processor chipset and a software stack executed by the processor chipset. The processor chipset can include one or more cores, one or more caches, a memory controller (e.g., NVDIMM controller), and a storage protocol controller (e.g., peripheral component interconnect express (PCIe) controller, SATA controller). The host system 102 uses the memory sub-system 103, for example, to write data to the memory sub-system 103 and read data from the memory sub-system 103.

The host system 102 can be coupled to the memory sub-system 103 via a physical host interface. Examples of a physical host interface include, but are not limited to, a serial advanced technology attachment (SATA) interface, a PCIe interface, universal serial bus (USB) interface, Fibre Channel, Serial Attached SCSI (SAS), Small Computer System Interface (SCSI), a double data rate (DDR) memory bus, a dual in-line memory module (DIMM) interface (e.g., DIMM socket interface that supports Double Data Rate (DDR)), Open NAND Flash Interface (ONFI), Double Data Rate (DDR), Low Power Double Data Rate (LPDDR), or any other interface. The physical host interface can be used to transmit data between the host system 102 and the memory sub-system 103. The host system 102 can further utilize an NVM Express (NVMe) interface to access the memory component (e.g., memory devices 105) when the memory sub-system 103 is coupled with the host system 102 by the PCIe interface. The physical host interface can provide an interface for passing control, address, data, and other signals between the memory sub-system 103 and the host system 102. FIG. 1 illustrates a memory sub-system 103 as an example. In general, the host system 102 can access multiple memory sub-systems via a same communication connection, multiple separate communication connections, and/or a combination of communication connections.

The memory devices 105, 106 can include any combination of the different types of non-volatile memory devices 105 and/or volatile memory devices 106. The volatile memory devices (e.g., memory device 106) can be, but are not limited to, random access memory (RAM), such as dynamic random access memory (DRAM) and synchronous dynamic random access memory (SDRAM).

Some examples of non-volatile memory devices (e.g., memory device 105) include negative-and (NAND) type flash memory and write-in-place memory, such as three-dimensional cross-point (“3D cross-point”) memory device, which is a cross-point array of non-volatile memory cells. A cross-point array of non-volatile memory can perform bit storage based on a change of bulk resistance, in conjunction with a stackable cross-gridded data access array. Additionally, in contrast to many flash-based memories, cross-point non-volatile memory can perform a write in-place operation, where a non-volatile memory cell can be programmed without the non-volatile memory cell being previously erased. NAND type flash memory includes, for example, two-dimensional NAND (2D NAND) and three-dimensional NAND (3D NAND).

Each of the memory devices 105 can include one or more arrays of memory cells. One type of memory cell, for example, single level cells (SLC) can store one bit per cell. Other types of memory cells, such as bi-level cells (BLCs), triple level cells (TLCs), quad-level cells (QLCs), and penta-level cells (PLCs) can store multiple bits per cells and can be referred to as multi-level cells (MLCs). In some embodiments, each of the memory devices 105, 106 can include one or more arrays of memory cells such as SLCs, BLCs, TLCs, QLCs, PLCs, or any combination of such. In some embodiments, a particular memory device can include an SLC portion, and a BLC portion, a TLC portion, a QLC portion, or a PLC portion of memory cells. The memory cells of the memory devices 105, 106 can be grouped as pages that can refer to a logical unit of the memory device used to store data. With some types of memory (e.g., NAND), pages can be grouped to form blocks.

Although non-volatile memory devices 105 such as a 3D cross-point array of non-volatile memory cells and NAND type memory (e.g., 2D NAND, 3D NAND) and 3D cross-point array of non-volatile memory cells are described, the memory device 105 can be based on any other type of non-volatile memory or storage device, phase change memory (PCM), self-selecting memory, other chalcogenide based memories, ferroelectric transistor random-access memory (FeTRAM), ferroelectric random access memory (FeRAM), magneto random access memory (MRAM), Spin Transfer Torque (STT)-MRAM, conductive bridging RAM (CBRAM), resistive random access memory (RRAM), oxide based RRAM (OxRAM), negative-or (NOR) flash memory, and electrically erasable programmable read-only memory (EEPROM).

The memory sub-system controller 104 (or controller 104 for simplicity) can communicate with the memory devices 105 to perform operations such as reading data, writing data, or erasing data at the memory devices 105 and other such operations. The memory sub-system controller 104 can include hardware such as one or more integrated circuits and/or discrete components, a buffer memory, or a combination thereof. The hardware can include a digital circuitry with dedicated (i.e., hard-coded) logic to perform the operations described herein. The memory sub-system controller 104 can be a microcontroller, special purpose logic circuitry (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc.), or other suitable processors.

The memory sub-system controller 104 can include a processor 107 (e.g., a processing device) configured to execute instructions stored in a local memory (e.g., not shown). The local memory of the memory sub-system controller 104 can include an embedded memory configured to store instructions for performing various processes, operations, logic flows, and routines that control operation of the memory sub-system 103, including handling communications between the memory sub-system 103 and the host system 102.

In some embodiments, the local memory can include memory registers storing memory pointers, fetched data, etc. The local memory can also include read-only memory (ROM) for storing micro-code, for example. While the example memory sub-system 103 in FIG. 1 has been illustrated as including the memory sub-system controller 104, in another embodiment of the present disclosure, a memory sub-system 103 does not include a memory sub-system controller 104, and can instead rely upon external control (e.g., provided by an external host, or by a processor or controller separate from the memory sub-system).

In general, the memory sub-system controller 104 can receive commands or operations from the host system 102 and can convert the commands or operations into instructions or appropriate commands to achieve the desired access to the memory devices 105 and/or the memory device 106. The memory sub-system controller 104 can be responsible for other operations such as wear leveling operations, garbage collection operations, error detection and error-correcting code (ECC) operations, encryption operations, caching operations, and address translations between a logical address (e.g., logical block address (LBA), namespace) and a physical address (e.g., physical block address) that are associated with the memory devices 105. The memory sub-system controller 104 can further include host interface circuitry to communicate with the host system 102 via the physical host interface. The host interface circuitry can convert the commands received from the host system into command instructions to access the memory devices 105 and/or the memory device 106 as well as convert responses associated with the memory devices 105 and/or the memory device 106 into information for the host system 102.

The memory sub-system 103 can also include additional circuitry or components that are not illustrated. In some embodiments, the memory sub-system 103 can include a cache or buffer (e.g., DRAM) and address circuitry (e.g., a row decoder and a column decoder) that can receive an address from the memory sub-system controller 104 and decode the address to access the memory devices 105. In various examples, a local memory can comprise cache 111 that can be utilized in conjunction with the memory device 105/106.

In some embodiments, the memory devices 105 include a local media controller 110 that operates in conjunction with memory sub-system controller 104 to execute operations on one or more memory cells of the memory devices 105. An external controller (e.g., memory sub-system controller 104) can externally manage the memory device 105 (e.g., perform media management operations on the memory device 105).

In various examples, the memory sub-system 103 can be a managed NAND (MNAND) device in which an external controller (e.g., 104) is packaged together with one or more NAND die (e.g., 105). In an MNAND device, the external controller 104 can handle high level memory management functions such as media management, and the local media controller 110 can manage some of the lower level memory processes such as when to perform program-verify operations, BLC, TLC, QLC, PLC program operations and/or calibrations, etc.

The memory sub-system controller 104 can also include a flash translation layer (FTL) 108. The FTL 108 can be responsible for various functions. For example, the FTL 108 can perform address translation (e.g., logical to physical), garbage collection, ECC, and wear leveling, among various other functions.

The memory sub-system controller 104 can also include a detection component 109. The detection component 109 can comprise an ASIC configured to perform the examples described herein. While the detection component 109 can be implemented as circuitry (e.g., ASIC), the detection component 109 can also be implemented as firmware and/or software. For example, the firmware and/or software can include instructions, which when executed by the memory sub-system controller 104, can cause the memory sub-system controller 104 to perform the examples described herein such as the examples describe by FIGS. 2, 3, 4. Although the detection component 109 is shown as being implemented separate from the FTL 108, the detection component 109 can be part of the FTL 108. The detection component 109 can detect a metadata area of the memory devices 105/106. Types of metadata areas can vary depending on the particular file system but can include a journal area, for example. The detection component 109 can also determine a particular file system 101 associated with writes to the metadata area(s) of the memory devices 105/106.

As used herein, the file system 101 controls how data is stored and retrieved. The file system 101 can control how data is separated as stored in the memory sub-system 103. The file system 102 can control the naming of data and/or portions (e.g., separated portions) of data. The file system 102 can control the structure and logical rules used to manage the data stored in the memory sub-system 103. The file system 101 can be a network file system, a database file system, a transactional file system, and/or a mobile device file system, for example. A mobile file system can be a fourth extended (EXT4) file system or a flash friendly file system (F2FS), for example.

The detection component 109 can further detect an IO pattern for the metadata area and/or the user area of the memory devices 105/106. As used herein, the terms detect, identify, and determine are used interchangeably.

The detection component 109 can, for instance, determine a file system type and/or a location of a metadata area (e.g., LBA range) associated with the file system based on a detected IO pattern. For example, forced unit access commands of an IO pattern can be monitored (e.g., tracked) and used to identify a metadata area given that the file system metadata areas are often accessed via forced unit accesses. For instance, file systems often employ forced unit access commands in a particular identifiable pattern in association with accessing a metadata area. Therefore, the forced unit access commands can also be used to detect a particular IO pattern. As used herein, a forced unit access command is a write command whose corresponding data is written directly to the memory device, bypassing the write cache (e.g., the cache 111).

In various examples, the FTL 108 can be configured to implement improvements to the performance of the memory device 103 responsive to identifying a metadata area (e.g., an EXT4 journal area). For example, the FTL 108 can reserve one or more blocks of the memory devices 105, 106 for a journal area. The FTL 108 can configure the memory cells of the reserved block of the memory devices 105, 106 to function as single level cells (SLCs). The FTL 108 can also implement garbage collection policies. The FTL 108 can implement the garbage collection policies via a garbage collector 112. The garbage collector 112 is shown as being implemented in the FTL 108 but can be implemented external to the FTL 108. The FTL 108 can implement a garbage collection policy for the journal area. The garbage collection policy implemented for the journal area can be different than the garbage collection policy implemented for different areas of the memory devices 105, 106.

The FTL 108 can also prioritize commands to the journal area as compared to different commands to different areas of the memory devices 105, 106. The FTL 108 can access a command queue 113. The FTL 108 can access the command queue 113 to select and prioritize the commands stored in the command queue 113. The command queue 113 can store incoming commands to the memory devices 105, 106. The garbage collector 112 and the command queue 113 are further described in FIG. 3.

FIG. 2 is a graph illustrating LBAs to which a sequence of commands are directed in accordance with some embodiments of the present disclosure. In FIG. 2, the x-axis represents time and the y-axis represents the LBA space corresponding to the memory device. As shown in FIG. 2, the LBA space includes a journal area 220. The remainder of the LBA space can be used for user data (e.g., the user LBAs), additional journal areas, and/or other metadata, for example.

The journal area 220 can be a dedicated metadata area of a journaling file system used to track file system changes not yet committed to storage. For example, the journal area 220 can store pointers to user LBAs and/or pointers to the journal area 220. The journal area 220 can also be referred to as a journal 220. The journal 220 can be implemented as a circular buffer. As an example, the journal 220 described in association with FIG. 2 can be associated with a journal block device of a journaling file system such as the extended 4 (EXT4) file system for Linux. Although the examples described in association with FIG. 2 relate to an EXT4 file system, embodiments are not limited to a particular type of journaling file system.

FIG. 2 illustrates a plurality of write commands 223, journal write commands 224-1, 224-2, 224-3, and 224-4 (referred to collectively as journal write commands 224), and journal commit commands 225-1, 225-2, 225-3, and 225-4 (referred to collectively as journal commit 225). As used herein, journal write commands (e.g., 224) refer to write commands directed to a journal area (e.g., 220), whereas regular write commands (e.g., 223) refer to write commands directed to a user LBA space. The journal commit commands 225 refer to a sequence of a flush command 226 followed by a forced unit access command (to the journal area 220). A forced unit access command refers to a write command whose corresponding data is written directly to the memory device, bypassing the write cache. Therefore, a journal commit 225, which is used at the end of a series of journal writes 224, involves a forced unit access following a flush command such that the data corresponding to the forced unit access is written directly to the memory device without utilizing a cache of the memory sub-system. In contrast to forced unit accesses, the journal write commands 224 and regular write commands 223 are written to a cache (e.g., write cache) of the memory sub-system prior to being written to the memory device (via a flush command). The cache can be implemented in various locations within a memory subsystem (e.g., 103 shown in FIG. 1). For example, the cache may be located on a memory device such as memory device 105, 106 and/or in local memory on the controller 104, among other locations.

A file system journal (e.g., EXT4 journal) can have identifiable (e.g., specific) traffic patterns (in terms of IO traffic) associated therewith during particular system utilization. The robustness and performance of the system can be sensitive to the performance of journal area 220. If the storage device can handle the traffic to the journal area 220 with fast performance and reliable data storage, then the user experience may benefit. Since the locations of one or more journals (e.g., 220) are unknown to a file system, it can be beneficial to identify the journal area(s) in order to improve system performance.

As an example, consider a user updates a database (e.g., when the user inserts a new telephone number, makes a new photo, synchronizes its account with cloud services, among others), which can involve at least two or three write operations in the journal area 220, which may be referred to as a journal of the journal. In accordance with a number of embodiments, upon determining the location of a journal area (e.g., 220), the memory sub-system can detect accesses to the journal area 220 and can act to speed up the performance of the detected accesses (as compared to the speed at which the accesses would have been performed had they not been identified as being directed to the journal area) thereby providing improved database performance and/or user experience. Also, since the write traffic issued to the storage device by a particular file system is a consistent percentage of the total write traffic throughout the lifespan of the storage device, by containing this traffic in specific underling device areas (e.g. in NAND SLC blocks), the overall endurance of the storage device can be enhanced.

A file system provides commands to the memory sub-system utilizing a particular protocol, such as an embedded multi-media controller (eMMC) protocol or a small computer system interface (SCSI) protocol, for example. The SCSI protocol can be associated with a universal flash storage (UFS) device and/or a solid state drive (SSD), for example.

Various examples described herein refer to file system commands generically as read, write, flush, forced unit access, read meta data, write metadata, discard, etc., since the specific file system commands are protocol dependent, and the file system is likely unaware of the underlying storage device (e.g., eMMC, UFS, SSD, etc.). Table 1 is provided as an example mapping of protocol specific commands/flags to generic file system commands. For example, a read command, as shown in Table 1, can be provided as a READ_10 command using a SCSI protocol. A write commands can be provided as a WRITE_10 command using a SCSI protocol. A forced unit access command can be provided as a WRITE_10 with a FUA tag (e.g., flag) using the SCSI protocol. A write command related to user file metadata can be provided as a WRITE_10 command using a system data tag (e.g. flag) using the SCSI protocol or a CMD23 or a CMD 25 with a DATA_TAG tag using the eMMC protocol. As used herein, a read or write command to a metadata area can comprise a command having a tag such as a DATA_TAG or a system data tag which can be referred to as a data tag.

TABLE 1 eMMC SCSI (e.g. UFS, SSD) Read CMD17/CMD23 + CMD18/ READ_10 CMD44 + CMD45 + CMD46 Write CMD24/CMD23 + CMD25/ WRITE_10 (Regular) CMD44 + CMD45 + CMD47 Forced unit CMD23 + CMD25 with WRITE_10 with FUA access REL_WRITE bit set bit set Write CMD23/CMD25 with WRITE_10 using System (Metadata) DATA_TAG bit set Data Tag group number Flush CMD6 SYNCHRONIZE_CACHE Discard CMD35/CMD36/CMD38 UNMAP

The EXT4 journal area 220 can have a specific traffic during regular system utilization. During regular utilization of the system, the journal area 220 can be accessed with a number of criteria. For example, a first criteria can include that journal write commands are executed in LBA sequential order. As used herein, LBA sequential order describes that a journal write at position N and consisting of M LBAs is followed by another journal write at position N+M. For example, an end LBA of a first write command to the journal area 220 can be adjacent to a start LBA of a second write command to the journal area 220. LBAs (e.g., first LBA and second LBA) can be adjacent if a first LBA is followed by a second LBA without a third LBA existing between the first LBA and the second LBA.

A second criteria can include that a series of regular write commands to the journal area 220 (e.g., the journal write commands 224) will end with a flush command (e.g., flush commands 226-1, 226-2, 226-3, 226-4, and 226-5) followed by a forced unit access command. This specific sequence of a flush command (e.g., 226) followed by a forced unit access command can be referred to as a journal commit (e.g., 225). It is noted that the journal commit commands 225 represent the combination of a forced unit access command to the journal area 220 and a corresponding respective flush command 226 immediately preceding the forced unit access. As used herein, a flush command refers to a command executed to move data from cache to a memory device. For example, the journal write commands 224 can involve writing to cache. The flush command can be used to commit the data from cache to the memory device. The forced unit access command involves storing data corresponding to the journal commits 225 directly to the memory device without first being written to the cache (e.g., the write cache is bypassed).

The journal area 220 can be identified (e.g., the particular LBA range can be determined) based on the first criteria and/or the second criteria. For example, the journal area 220 can be identified by determining that the write commands are being executed in sequential LBA order. The journal area 220 can also be identified based on a flush command being followed by a forced unit access command. A forced unit access command can be identified by the use of a tag (e.g., REL_WRITE and/or FUA tags).

FIG. 2 shows the sequential and cyclic nature of the journal area 220 and the specific sequence of commands used to access the journal area 220. In various embodiments, each journal write command 224 (or series of journal write commands) is followed by a flush command and a forced unit access command. As noted above, the specific sequence of a flush command 226 followed by a forced unit access command is referred to as a respective journal commit command 225. For example, the journal write command 224-1 is sequentially followed by flush command 226-1 and a forced unit access corresponding to the journal commit command 225-1. As shown in FIG. 2, within the journal area 220, write commands are executed in sequential order. For example, the starting LBA corresponding to journal write 224-2 is adjacent to the end LBA corresponding to journal commit 225-1. That is, the ending LBA of the forced unit access corresponding to journal commit 225-1 immediately precedes the beginning LBA corresponding to journal write 224-2.

In various embodiments, and as shown in FIG. 2, the journal area 220 can be implemented as a circular buffer, for example, such that the beginning and ending LBAs are treated as adjacent LBAs. For instance, the end LBA of the journal commit command 225-3 corresponds to the end LBA of the journal area 220 and the start LBA of the journal write command 224-4 corresponds to the start LBA of the journal area 220. In various examples, the journal write command 224-4 can be considered as occurring sequentially to the journal commit 224-3 due to the journal write command 224-4 being adjacent to the journal commit command 225-4 and the journal commit command 225-4 being adjacent to the journal write command 224-1. As described further herein, in accordance with a number of embodiments of the present disclosure, the cyclic nature of the access pattern associated with the journal area 220 can be used to identify the particular location (e.g., LBA range) of the journal area 220 within the LBA space of a memory device.

A method for identifying a journal area can be performed by processing logic that can include hardware (e.g., processing device, circuitry, dedicated logic, programmable logic, microcode, hardware of a device, integrated circuit, etc.), software (e.g., instructions run or executed on a processing device), or a combination thereof. In some embodiments, the method is performed by the detection component 109 of FIG. 1. Although shown in a particular sequence or order, unless otherwise specified, the order of the processes can be modified. Thus, the illustrated embodiments should be understood only as examples, and the illustrated processes can be performed in a different order, and some processes can be performed in parallel. Additionally, one or more processes can be omitted in various embodiments. Thus, not all processes are required in every embodiment. Other process flows are possible.

The method includes receiving a command (e.g., at a memory sub-system from a host). The method includes determining whether the command is a write command. If the received command is not a write command, then it is executed.

If the received command is a write command, the method includes determining whether the received command is contiguous or overlaps with a candidate journal area (e.g., journal, area 220). As used herein, a candidate journal area describes a range of LBAs that may have the possibility of being a journal area. Access commands to the candidate journal area can be tracked to determine whether the candidate journal area is used sufficiently to consider the candidate journal area as a journal area. Overlapping with regards to a candidate journal area describes whether the range of LBAs of the received command is within the range of LBAs of the candidate journal area. Overlapping can also describe whether the LBAs of the received command are continuous with the LBAs of the candidate journal area. The journal write command 224-4 does not overlap with the candidate journal area which can include the LBAs of the journal write commands 224-1, 224-2, and 224-3, for example. The journal write commands 224-3 can overlap with the candidate journal area which includes the LBAs of the journal write commands 224-1 and 224-2, for example.

If the received command does not overlap with the candidate journal area, the received command can be reviewed to determine whether the receive command is a forced unit access command. The method can determine whether the received command comprises or is associated with a tag. A tag associated with the received command can be reviewed to determine whether the tag is one of the REL_WRITE tag and a FUA tag. If the tag associated with the receive command is one of REL_WRITE tag and a FUA tag, then the received command can be a forced unit access command. If the received command is not a forced unit access command, then the command can be executed.

Although the method can include determining whether the received method overlaps with the candidate journal area and determining whether the received command is a forced unit access command, the method can perform both determinations in a different order or only perform one of the determinations. For example, the method can determine whether the received command is a forced unit access command prior to determining whether the received command overlaps with the candidate journal area. The method can, alternatively, only perform one of the determinations including determining whether the received command overlaps with the candidate journal area or determining whether the received command is a forced unit access command.

If the received command overlaps with the candidate journal area or if the received command is a forced unit access command, then the method can include adding or merging with the list of candidate journal areas. A new candidate journal area can be added to a list of candidate journal areas if the received command does not overlap with a candidate journal area and is a forced unit access command. The received command can be merged with the candidate journal area if the received command overlaps with the candidate journal area. A command can be merged with the candidate journal area if the LBAs of the received command are merged with (e.g., added to) the LBAs of the candidate journal area.

A determination can be made as to whether the received command and/or the newly created candidate journal area is contiguous to an already existing candidate journal area. A received command or a newly created candidate journal area can be contiguous if the LBAs of the newly created candidate journal area or the received command are adjacent to the LBAS of the already existing candidate journal area.

If the received command or the newly created candidate journal area is contiguous to the already existing candidate journal area, then a counter can be incremented for the already existing candidate journal area. The counter can be referred to as a hit counter. The counter can represent a use of the already existing candidate journal area. For instance, the more a candidate journal area is used in a contiguous manner then the more likely the candidate journal area is in fact the journal area. A counter can be incremented for the already existing candidate journal area. If the received command or the newly created candidate journal area is not contiguous to the already existing candidate journal area, then the method can include determining if the counter for the candidate journal area is greater than a threshold. If the counter is greater than the threshold, then the method can mark the received command as a journal write command and/or can mark the candidate journal area as a journal area. Marking the received command as a journal write command and/or the candidate journal area as a journal area can provide the ability to expedite execution of the journal write command to limit the stalling of the memory device, memory sub-system, and/or computing environment. The method can then continue by executing the received command.

FIG. 3 illustrates an example virtual block 334 in accordance with some embodiments of the present disclosure. FIG. 3 depicts a plurality of memory devices 305-1, 305-2, 305-3, 305-4. The memory devices 305-1, 305-2, 305-3, 305-4 collectively can be referred to as the memory device 305.

In various examples, each of the memory devices 305-1, 305-2, 305-3, 305-4 can be a separate NAND device. For example, the memory device 305-1 can be a first NAND device, the memory device 305-2 can be a second NAND device, the memory device 305-3 can be a third NAND device, and the memory device 305-4 can be a fourth NAND device. The memory device 305 can be a managed NAND (MNAND) device which comprises the first NAND device, the second NAND device, the third NAND device, the fourth AND device, and a controller, among other components.

The memory devices 305-1, 305-2, 305-3, 305-4 (e.g., NAND devices) can be divided into ranges referred to as blocks. One or more of the memory devices 305-1, 305-2, 305-3, 305-4 can be divided into virtual blocks 334. The virtual block 334 can comprise a same block from each of the memory devices 305-1, 305-2, 305-3, 305-4 or different blocks from each of the memory devices 305-1, 305-2, 305-3, 305-4. For example, the virtual block 334 can comprise a block 335-1 from the memory device 305-1, a block 335-2 from the memory device 305-2, a block 335-3 from the memory device 305-3, and a block 335-4 from the memory device 305-4. Although four memory devices 305-1, 305-2, 305-3, 305-4 are shown in FIG. 3, the virtual block 334 can comprise blocks from more than four memory devices or blocks from less than four memory devices. The union of a first block from each of the memory devices 305-1, 305-2, 305-3, 305-4 can be referred to as a first virtual block (e.g., the virtual block 334).

In various instances, the memory cells of the virtual block 334 can be configured as SLC, BLC, TLC, QLC, or PLC. Given that handling of traffic to the journal area of the memory device 305 can have an impact on the use of the memory device 305 and/or on the use of a system comprising the memory device, the FTL can be configured to reserve one or more virtual blocks, including the virtual block 334, for journal traffic. As used herein, journal traffic describes traffic to a journal area including access commands to the journal area.

A journal write command can be directed to the virtual block 334 reserved for a journal area each time the journal write command is detected. The journal write command can be detected as described in FIG. 2. By reserving the virtual blocks (e.g., the virtual block 334) for a journal area, the write performance of the journal area can be enhanced as compared to a journal area that is implemented without reserving a one or more virtual blocks. The virtual block 334, implemented using SLC, can offer a better write throughput as compared to other kinds of virtual blocks. As used herein, throughput describes the efficiency in writing data or reading data (e.g., accessing data).

In various examples, incoming commands can be monitored to determine a journal area of the memory device 305. The commands can be incoming to the memory device 305. The incoming commands can comprise mixed traffic 331. The mixed traffic 331 comprises journal traffic 332 and non-journal traffic 333. The non-journal traffic 333 (e.g., “normal” traffic) can include access commands to areas of the memory device 305 reserved for user data, operating system data, and/or different types of data. The journal traffic 332 (e.g., journal commands) can be identified and used to determine a journal area of the memory device 305. Responsive to determining the journal area, subsequent writes to the journal area can be directed to SLC virtual blocks (e.g., virtual block 334) reserved for writes to the journal area.

The mixed traffic 331 can be monitored by determining whether the incoming commands to a start logical block address (LBA) and an end LBA are write commands. Responsive to determining that the incoming commands are write commands, a determination can be made as to whether the incoming commands are forced unit access commands. Responsive to determining that the write commands are forced unit access commands, the start LBA to the end LBA can be marked as the journal area of the memory device responsive to the start LBA to the end LBA being accessed a threshold number of times. The journal area can be an EXT4 filesystem journal area. As such, the virtual block 334 can have a start LBA and the end LBA of the journal area.

In various examples, the FTL can comprise a garbage collector (e.g., the garbage collector 112 in FIG. 1). The garbage collector is hardware or firmware which can be utilized to implement a garbage collection policy. The garbage collection policy defines how a garbage collection of the memory device 305 is carried out. The garbage collector can utilize heuristics to determine which virtual blocks are selected and cleaned. As used herein, cleaning the virtual block 334 can include erasing the data stored in the memory cells that comprise the virtual block 334.

In various instances, the garbage collector can implement a garbage collection policy specific to the virtual block 334. The garbage collection policy specific to the virtual block 334 can be implemented responsive to reserving the virtual block 334 for the journal area. The garbage collecting policy implemented by the garbage collector for the virtual block 334 can avoid or delay cleaning operations on the virtual block 334.

The garbage collection policy implemented for the virtual block 334 may delay or avoid cleaning operations given that the virtual block 334 may not need to be cleaned as often as other virtual blocks. The memory cells of the virtual block 334 are overwritten due to the nature of the traffic to the journal area. Given that the journal area is written circularly, the virtual block 334 is cleaned without the need to implement cleaning operations or is cleaned independent of cleaning operations implemented in a delayed manner. For example, given that the journal area is written circularly, data stored in the journal area can be re-written at set intervals of time. Re-writing data at set intervals of time can constitute a cleaning of the memory cells that store the data. As such, memory cells of the journal area can be re-written (e.g., cleaned) without performing cleaning operations implemented by a garbage collector using a garbage policy.

In a number of examples, a same garbage collection policy can be implemented for each of the blocks 335-1, 335-2, 335-3, 335-4 of the memory devices 305-1, 305-2, 305-3, 305-4. Implementing a same garbage collection policy for each of the blocks 335-1, 335-2, 335-3, 335-4 of the memory devices 305-1, 305-2, 305-3, 305-4 can include implementing the same garbage collection policy for each of the blocks 335-1, 335-2, 335-3, 335-4 independently as opposed to implementing a same garbage collection policy for the blocks 335-1, 335-2, 335-3, 335-4 as a unit. A different garbage collection policy can also be implemented for each of the blocks 335-1, 335-2, 335-3, 335-4 of the memory devices 305-1, 305-2, 305-3, 305-4 where the different garbage collection policies are specific to the blocks 335-1, 335-2, 335-3, 335-4. For example, a first garbage collection policy can be implemented for the block 335-1, a second garbage collection policy can be implemented for the block 335-2, a third garbage collection policy can be implemented for the block 335-3, and a fourth garbage collection policy can be implemented for the block 335-4, where the first, the second, the third, and the fourth garbage collection policies are selected responsive to the virtual block 334 being reserved for a journal area.

By utilizing a garbage collection policy specific to the virtual block 334 the end of life requirements of the memory device 305 can be improved. By delaying or limiting the garbage collection operations implemented for the virtual block 334, the wear of the memory device 305 can be limited as compared to different garbage collection policies. Limiting the wear of the memory device 305 can lengthen the life of the memory device 305.

By implementing a garbage collection policy specific to the virtual block 334 a write amplification factor of the memory device 305 can be contained. As used herein, a write amplification factor describes the writing of an amount of data which is a multiple of the actual amount of data written to the memory device 305. Configuring the memory cells of the virtual block 334 to function as SLC can improve the wear out specification of the virtual block 334 as compared to different memory cells of different virtual blocks that are configured to function as BLC/TLC/QLC/PLC.

The command queue 113 of FIG. 1 is shown as being implemented external to the FTL 108 but can be implemented in the FTL 108. The command queue can store the commands that comprise the mixed traffic 331. For example, the command queue can store the commands that comprise the journal traffic 332 and the commands that comprise the non-journal traffic 333. The non-journal traffic may be referred to as “normal” traffic 333 can comprise commands such as user data read/write commands, garbage collection commands, etc.

An FTL may prioritize journal write commands over other commands. The prioritization of the journal write commands can improve system performance given that the filesystem is not accessed while journal modifications are in progress. An FTL which prioritizes the journal write commands can make the filesystem unavailability period shorter and provide overall better system performance than an FTL which does not prioritize the journal write commands.

The journal write commands (e.g., journal traffic 332) can be prioritized utilizing the command queue. For example, the commands in the command queue can be reorganized such that the journal write commands are processed before other commands stored in the command queue. The journal command stored in the command queue can be selected for execution prior to the non-journal commands stored in the command queue. The journal write commands can be prioritized over garbage collection commands among other types of commands that are non-journal write commands.

The benefits of implementing the examples described herein include an improved user perceived performance, an improved endurance of the memory device 305, and better write performance and latency quality of service for the memory device 305. Improving a user perceived performance can be achieved by prioritizing journal accesses to limit the offline time of the filesystem. Improving the endurance of the memory device 305 can be achieved by accurately selecting and segregating journal write traffic as compared to standard write traffic. Improving the endurance of the memory device 305 can describe extending the life of the memory device 305. Improving the write performance and latency quality of service for the memory device 305 can be achieved by using SLC block and by avoiding or limiting performing garbage collection operations in the memory device 305. Avoiding or limiting performing garbage collection operations can improve write performance to the virtual block 334 by reducing the latency for performing access commands to the virtual block 334 given that the garbage collection operations are avoided or limited.

FIG. 4 is a flow diagram of an example method 480 corresponding to detection circuitry in accordance with some embodiments of the present disclosure. The method 480 can be performed by processing logic that can include hardware (e.g., processing device, circuitry, dedicated logic, programmable logic, microcode, hardware of a device, integrated circuit, etc.), software (e.g., instructions run or executed on a processing device), or a combination thereof. In some embodiments, the method 480 is performed by the FTL 108 of FIG. 1. Although shown in a particular sequence or order, unless otherwise specified, the order of the processes can be modified. Thus, the illustrated embodiments should be understood only as examples, and the illustrated processes can be performed in a different order, and some processes can be performed in parallel. Additionally, one or more processes can be omitted in various embodiments. Thus, not all processes are required in every embodiment. Other process flows are possible.

At 481, incoming commands can be monitored to determine a journal area of a memory device. At 482, responsive to determining the journal area, a garbage collection policy specific to the journal area can be implemented.

Implementing the garbage collection policy specific to the journal area can include delaying a garbage collection of the journal area. The delaying of the garbage collection policy can be in relation to (e.g., compared to) different garbage collection policies specific to non-journal areas. The garbage collection policy of the journal area can include a delay time of the garbage collection based on a circular writing of the journal area. The delay time can describe a delay interval of the garbage collection as compared to garbage collection policies for non-journal areas. The delay time can be selected based on a time interval of the circular writing of the journal area. For example, the delay time can be a multiple of the time interval of the circular writing of the journal area.

In various examples, delaying the garbage collection of the journal area can include indefinitely delaying the garbage collection of the journal area. Indefinitely delaying the garbage collection of the journal area can include suspending garbage collection commands to the journal area. Indefinitely delaying the garbage collection of the journal area can also include refraining from implementing a garbage collection policy for the journal area or refraining from providing garbage collection commands to the journal area.

The journal data of the journal area can be separated from non-journal data in a separate block of the memory device. That is the journal data can be stored in the separate block of the memory device. The garbage collection policy specific to the journal area can be implemented on the separate block of the memory device. The memory cells of the separate block can be SLC such that the separate block can be referred to as a SLC block. The garbage collection policy specific to the journal area can limit a write amplification factor of the journal area as compared to other blocks of the memory device.

In various instances, the incoming commands can be monitored to determine a journal area of the memory device. The additional commands to the journal area can be prioritized over different commands to different areas of the memory device. The additional commands can be prioritized over the different commands in a queue (e.g., command queue). The prioritized additional command can be executed prior to the execution of the different commands. The prioritized additional commands can be executed in less time than execution of the additional commands without prioritization. The additional command can be prioritized over garbage collection operations.

FIG. 5 illustrates an example machine of a computer system 590 within which a set of instructions, for causing the machine to perform one or more of the methodologies discussed herein, can be executed. In some embodiments, the computer system 590 can be analogous to the memory sub-system controller 104 of FIG. 1. In alternative embodiments, the machine can be connected (e.g., networked) to other machines in a LAN, an intranet, an extranet, and/or the Internet. The machine can operate in the capacity of a server or a client machine in client-server network environment, as a peer machine in a peer-to-peer (or distributed) network environment, or as a server or a client machine in a cloud computing infrastructure or environment.

The machine can be a personal computer (PC), a tablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a server, a network router, a switch or bridge, or another machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while a single machine is illustrated, the term “machine” shall also be taken to include a collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform one or more of the methodologies discussed herein.

The example computer system 590 includes a processing device 592, a main memory 594 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM), etc.), a static memory 598 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage system 599, which communicate with each other via a bus 597. The data storage system 599 can be a memory sub-system such as memory sub-system 103 described in FIG. 1 (e.g., UFS, eMMC, etc.).

The processing device 592, which can be analogous to the processor 107 in FIG. 1, represents one or more general-purpose processing devices such as a microprocessor, a central processing unit, or the like. More particularly, the processing device can be a complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets, or processors implementing a combination of instruction sets. The processing device 592 can also be one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. The processing device 592 is configured to execute instructions 593 for performing the operations and steps discussed herein. The computer system 590 can further include a network interface device 595 to communicate over the network 596.

The data storage system 599 can include a machine-readable storage medium 591 (also known as a computer-readable medium) on which is stored one or more sets of instructions 593 or software embodying one or more of the methodologies or functions described herein. The instructions 593 can also reside, completely or at least partially, within the main memory 594 and/or within the processing device 592 during execution thereof by the computer system 590, the main memory 594 and the processing device 592 also constituting machine-readable storage media. The machine-readable storage medium 591, data storage system 599, and/or main memory 594 can correspond to the memory sub-system 103 of FIG. 1.

In one embodiment, the instructions 593 include instructions to implement functionality corresponding to the FTL 108 of FIG. 1. The instructions can include an FTL instruction 589 associated with improving memory device performance based on storage traffic pattern detection (e.g., FTL 108 in FIG. 1). While the machine-readable storage medium 591 is shown in an example embodiment to be a single medium, the term “machine-readable storage medium” should be taken to include a single medium or multiple media that store the one or more sets of instructions. The term “machine-readable storage medium” shall also be taken to include a medium that is capable of storing or encoding a set of instructions for execution by the machine and that cause the machine to perform one or more of the methodologies of the present disclosure. The term “machine-readable storage medium” shall accordingly be taken to include, but not be limited to, solid-state memories, optical media, and magnetic media.

Some portions of the preceding detailed descriptions have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the ways used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of operations leading to a desired result. The operations are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. The present disclosure can refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage systems.

The present disclosure also relates to an apparatus for performing the operations herein. This apparatus can be specially constructed for the intended purposes, or it can include a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program can be stored in a computer readable storage medium, such as, but not limited to, types of disk including floppy disks, optical disks, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or type of media suitable for storing electronic instructions, each coupled to a computer system bus.

The algorithms and displays presented herein are not inherently related to a particular computer or other apparatus. Various general purpose systems can be used with programs in accordance with the teachings herein, or it can prove convenient to construct a more specialized apparatus to perform the method. The structure for a variety of these systems will appear as set forth in the description below. In addition, the present disclosure is not described with reference to a particular programming language. It will be appreciated that a variety of programming languages can be used to implement the teachings of the disclosure as described herein.

The present disclosure can be provided as a computer program product, or software, that can include a machine-readable medium having stored thereon instructions, which can be used to program a computer system (or other electronic devices) to perform a process according to the present disclosure. A machine-readable medium includes a mechanism for storing information in a form readable by a machine (e.g., a computer). In some embodiments, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., a computer) readable storage medium such as a read only memory (“ROM”), random access memory (“RAM”), magnetic disk storage media, optical storage media, flash memory devices, etc.

In the foregoing specification, embodiments of the disclosure have been described with reference to specific example embodiments thereof. It will be evident that various modifications can be made thereto without departing from the broader spirit and scope of embodiments of the disclosure as set forth in the following claims. The specification and drawings are, accordingly, to be regarded in an illustrative sense rather than a restrictive sense. 

1. A system comprising: a memory device; and a controller coupled to the memory device comprising memory cells operable as single level cells (SLCs) and multi-level cells (MLCs), wherein the memory device is configured to: monitor incoming commands to determine a journal area of the memory device; and responsive to determining the journal area, direct subsequent writes to the journal area to SLC virtual blocks reserved for writes to the journal area.
 2. The system of claim 1, wherein the controller is further configured to: determine whether the incoming commands to a start logical block address (LBA) and an end LBA are write commands; responsive to determining that the incoming commands are write commands, determine whether the incoming commands are forced unit access commands.
 3. The system of claim 2, wherein the controller is further configured to: responsive to determining that the write commands are the forced unit access commands, mark the start LBA to the end LBA as the journal area of the memory device responsive to the start LBA to the end LBA being accessed a threshold number of times, wherein the journal area is a fourth extended (EXT4) filesystem journal area.
 4. The system of claim 3, wherein the controller is further configured to configure the memory cells of the journal area to function as a virtual block including the start LBA and the end LBA of the journal area.
 5. The system of claim 4, wherein the controller is further configured to configure the memory cells of the virtual block wherein the virtual block comprises blocks from a plurality of memory devices including the memory device.
 6. The system of claim 5, wherein the controller is further configured to configure the virtual block from the plurality of memory devices as comprising a same block from each of the plurality of memory devices.
 7. The system of claim 6, wherein the plurality of memory devices are a managed NAND device and wherein each of the plurality of memory device are NAND devices.
 8. A method, comprising: monitoring incoming commands to determine a journal area of a memory device; and responsive to determining the journal area, implementing a garbage collection policy specific to the journal area.
 9. The method of claim 8, wherein implementing the garbage collection policy specific to the journal area further comprises delaying a garbage collection of the journal area as compared to different garbage collection policies specific to non-journal areas.
 10. The method of claim 9, wherein the garbage collection policy of the journal area includes a delay time of the garbage collection based on a circular writing of the journal area.
 11. The method of claim 9, wherein delaying the garbage collection of the journal area further comprises indefinitely delaying the garbage collection of the journal area.
 12. The method of claim 8, further comprising separating journal data of the journal area from non-journal data in a separate block of the memory device.
 13. The method of claim 12, further comprising implementing the garbage collection policy specific to the journal area on the separate block of the memory device.
 14. The method of claim 13, further comprising implementing the garbage collection policy specific to the journal area on the separate block of the memory device, wherein the separate block is an SLC block.
 15. The method of claim 14, wherein the garbage collection policy specific to the journal area limits a write amplification factor of the journal area as compared to other blocks of the memory device.
 16. A system, comprising: a memory device; and a controller coupled to the memory device and configured to: monitor incoming commands to determine a journal area of the memory device; and prioritize additional commands to the journal area over different commands to different areas of the memory device.
 17. The system of claim 16, further comprising a queue and wherein the controller is further configured to prioritize the additional commands over the different commands as stored in the queue.
 18. The system of claim 17, wherein the controller configured to prioritize the additional commands is further configured to execute the prioritized additional command prior to executing the different commands.
 19. The system of claim 16, wherein the controller is further configured to execute the prioritized additional commands in less time than executing the additional commands without prioritization.
 20. The system of claim 16, wherein the controller configured to prioritize the additional commands is further configured to prioritize the additional command over garbage collection operations. 